ಸ್ಕಿಕಿಟ್-ಲರ್ನ್‌ನ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ. K-ಫೋಲ್ಡ್, ಸ್ತ್ರತೀಕರಿಸಿದ, ಸಮಯ ಸರಣಿ CV ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಜಾಗತಿಕ ದತ್ತಾಂಶ ವಿಜ್ಞಾನಿಗಳಿಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಪೈಥಾನ್ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅನ್ವೇಷಿಸಿ.
ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಕರಗತ: ಮಾದರಿ ಆಯ್ಕೆಗಾಗಿ ಸದೃಢ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರಗಳಿಗಾಗಿ ಜಾಗತಿಕ ಮಾರ್ಗದರ್ಶಿ
ಯಂತ್ರ ಕಲಿಕೆಯ ವಿಶಾಲ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಭೂದೃಶ್ಯದಲ್ಲಿ, ಭವಿಷ್ಯಸೂಚಕ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವುದು ಅರ್ಧದಷ್ಟು ಯುದ್ಧ ಮಾತ್ರ. ಮತ್ತೊಂದು, ಅಷ್ಟೇ ನಿರ್ಣಾಯಕ ಅರ್ಧವು ಈ ಮಾದರಿಗಳು ಕಾಣದ ಡೇಟಾದಲ್ಲಿ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅವುಗಳನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಸರಿಯಾದ ಮೌಲ್ಯಮಾಪನವಿಲ್ಲದೆ, ಅತ್ಯಾಧುನಿಕ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಸಹ ದಾರಿತಪ್ಪಿಸುವ ತೀರ್ಮಾನಗಳು ಮತ್ತು ಕನಿಷ್ಠ ನಿರ್ಧಾರಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಈ ಸವಾಲು ಸಾರ್ವತ್ರಿಕವಾಗಿದೆ, ಎಲ್ಲಾ ಕೈಗಾರಿಕೆಗಳು ಮತ್ತು ಭೌಗೋಳಿಕ ಪ್ರದೇಶಗಳಲ್ಲಿನ ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆ ಇಂಜಿನಿಯರ್‌ಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ, ಸದೃಢ ಮಾದರಿ ಮೌಲ್ಯಮಾಪನ ಮತ್ತು ಆಯ್ಕೆಗಾಗಿ ಅತ್ಯಂತ ಮೂಲಭೂತ ಮತ್ತು ಶಕ್ತಿಶಾಲಿ ತಂತ್ರಗಳಲ್ಲಿ ಒಂದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ: ಪೈಥಾನ್‌ನ ಜನಪ್ರಿಯ ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಲೈಬ್ರರಿಯಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿರುವ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್. ನೀವು ಲಂಡನ್‌ನಲ್ಲಿ ಅನುಭವಿ ವೃತ್ತಿಪರರಾಗಿರಲಿ, ಬೆಂಗಳೂರಿನಲ್ಲಿ ಬೆಳೆಯುತ್ತಿರುವ ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಕರಾಗಿರಲಿ, ಅಥವಾ ಸಾವೊ ಪಾಲೊದಲ್ಲಿ ಯಂತ್ರ ಕಲಿಕೆ ಸಂಶೋಧಕರಾಗಿರಲಿ, ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಯಂತ್ರ ಕಲಿಕೆ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಈ ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಅನ್ವಯಿಸುವುದು ಅತಿಮುಖ್ಯವಾಗಿದೆ.
ನಾವು ವಿವಿಧ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ಅವುಗಳ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಸ್ಪಷ್ಟ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಪೈಥಾನ್ ಕೋಡ್ ಬಳಸಿ ಅವುಗಳ ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ. ನಿಮ್ಮ ಮಾದರಿಗಳು ಉತ್ತಮವಾಗಿ ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತವೆ ಮತ್ತು ಸ್ಥಿರವಾದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಡೇಟಾಸೆಟ್ ಮತ್ತು ಮಾಡೆಲಿಂಗ್ ಸವಾಲಿಗೆ ಸೂಕ್ತವಾದ ತಂತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ಜ್ಞಾನವನ್ನು ಒದಗಿಸುವುದು ನಮ್ಮ ಗುರಿಯಾಗಿದೆ.
ಓವರ್‌ಫಿಟ್ಟಿಂಗ್ ಮತ್ತು ಅಂಡರ್‌ಫಿಟ್ಟಿಂಗ್‌ನ ಅಪಾಯ: ಸದೃಢ ಮೌಲ್ಯಮಾಪನ ಏಕೆ ಮುಖ್ಯ?
ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್‌ಗೆ ಧುಮುಕುವ ಮೊದಲು, ಯಂತ್ರ ಕಲಿಕೆಯ ಅವಳಿ ವಿರೋಧಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅವಶ್ಯಕ: ಓವರ್‌ಫಿಟ್ಟಿಂಗ್ ಮತ್ತು ಅಂಡರ್‌ಫಿಟ್ಟಿಂಗ್.
- ಓವರ್‌ಫಿಟ್ಟಿಂಗ್: ಇದು ಮಾದರಿಯು ತರಬೇತಿ ಡೇಟಾವನ್ನು ಅತಿಯಾಗಿ ಕಲಿಯುವಾಗ ಸಂಭವಿಸುತ್ತದೆ, ಹೊಸ, ಕಾಣದ ಡೇಟಾಗೆ ಸಾಮಾನ್ಯೀಕರಿಸದ ಶಬ್ದ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಮಾದರಿಗಳನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ. ಅತಿಯಾಗಿ ಹೊಂದಿಕೆಯಾದ ಮಾದರಿಯು ತರಬೇತಿ ಸೆಟ್‌ನಲ್ಲಿ ಅಸಾಧಾರಣವಾಗಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಆದರೆ ಪರೀಕ್ಷಾ ಡೇಟಾದಲ್ಲಿ ಕಳಪೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ಪರೀಕ್ಷೆಗೆ ಉತ್ತರಗಳನ್ನು ಕಂಠಪಾಠ ಮಾಡುವ ವಿದ್ಯಾರ್ಥಿಯನ್ನು ಊಹಿಸಿಕೊಳ್ಳಿ ಆದರೆ ಅದೇ ವಿಷಯದ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಹೆಣಗಾಡುತ್ತಾನೆ.
- ಅಂಡರ್‌ಫಿಟ್ಟಿಂಗ್: ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಮಾದರಿಯು ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿನ ಆಧಾರವಾಗಿರುವ ಮಾದರಿಗಳನ್ನು ಸೆರೆಹಿಡಿಯಲು ತುಂಬಾ ಸರಳವಾದಾಗ ಅಂಡರ್‌ಫಿಟ್ಟಿಂಗ್ ಸಂಭವಿಸುತ್ತದೆ. ಇದು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾ ಎರಡರಲ್ಲೂ ಕಳಪೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಗ್ರಹಿಸದ ವಿದ್ಯಾರ್ಥಿಯಂತೆ ಮತ್ತು ಆದ್ದರಿಂದ ಸರಳ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ವಿಫಲನಾಗುತ್ತಾನೆ.
ಸಾಂಪ್ರದಾಯಿಕ ಮಾದರಿ ಮೌಲ್ಯಮಾಪನವು ಸಾಮಾನ್ಯವಾಗಿ ಸರಳವಾದ ತರಬೇತಿ/ಪರೀಕ್ಷಾ ವಿಭಜನೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಉತ್ತಮ ಆರಂಭಿಕ ಹಂತವಾಗಿದ್ದರೂ, ಒಂದೇ ವಿಭಜನೆಯು ಸಮಸ್ಯಾತ್ಮಕವಾಗಿರಬಹುದು:
- ಕಾರ್ಯಕ್ಷಮತೆಯು ನಿರ್ದಿಷ್ಟ ಯಾದೃಚ್ಛಿಕ ವಿಭಜನೆಯನ್ನು ಹೆಚ್ಚು ಅವಲಂಬಿಸಿರುತ್ತದೆ. "ಅದೃಷ್ಟದ" ವಿಭಜನೆಯು ಕಳಪೆ ಮಾದರಿಯನ್ನು ಉತ್ತಮವಾಗಿ ಕಾಣುವಂತೆ ಮಾಡಬಹುದು, ಮತ್ತು ಪ್ರತಿಯಾಗಿ.
- ಡೇಟಾಸೆಟ್ ಚಿಕ್ಕದಾಗಿದ್ದರೆ, ಒಂದೇ ವಿಭಜನೆಯು ತರಬೇತಿಗಾಗಿ ಕಡಿಮೆ ಡೇಟಾ ಅಥವಾ ಪರೀಕ್ಷೆಗಾಗಿ ಕಡಿಮೆ ಡೇಟಾ ಎಂದರ್ಥ, ಇವೆರಡೂ ಕಡಿಮೆ ವಿಶ್ವಾಸಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಂದಾಜುಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
- ಇದು ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ವ್ಯತ್ಯಾಸದ ಸ್ಥಿರ ಅಂದಾಜನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ.
ಇಲ್ಲಿ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ರಕ್ಷಣೆಗೆ ಬರುತ್ತದೆ, ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅಂದಾಜು ಮಾಡಲು ಹೆಚ್ಚು ಸದೃಢ ಮತ್ತು ಸಂಖ್ಯಾಶಾಸ್ತ್ರೀಯವಾಗಿ ಉತ್ತಮ ವಿಧಾನವನ್ನು ನೀಡುತ್ತದೆ.
ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಎಂದರೇನು? ಮೂಲಭೂತ ಕಲ್ಪನೆ
ತನ್ನ ಮೂಲದಲ್ಲಿ, ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಒಂದು ಸೀಮಿತ ದತ್ತಾಂಶ ಮಾದರಿಯಲ್ಲಿ ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಬಳಸುವ ಮರು-ಮಾದರಿ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಈ ಕಾರ್ಯವಿಧಾನವು ದತ್ತಾಂಶವನ್ನು ಪೂರಕ ಉಪವಿಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುವುದು, ಒಂದು ಉಪವಿಭಾಗದಲ್ಲಿ ("ತರಬೇತಿ ಸೆಟ್") ವಿಶ್ಲೇಷಣೆ ನಡೆಸುವುದು ಮತ್ತು ಇನ್ನೊಂದು ಉಪವಿಭಾಗದಲ್ಲಿ ("ಪರೀಕ್ಷಾ ಸೆಟ್") ವಿಶ್ಲೇಷಣೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹಲವಾರು ಬಾರಿ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ, ಉಪವಿಭಾಗಗಳ ಪಾತ್ರಗಳನ್ನು ಅದಲುಬದಲು ಮಾಡಲಾಗುತ್ತದೆ, ಮತ್ತು ನಂತರ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಅಂದಾಜನ್ನು ಉತ್ಪಾದಿಸಲು ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಯೋಜಿಸಲಾಗುತ್ತದೆ.
ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್‌ನ ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳು ಹೀಗಿವೆ:
- ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಂದಾಜುಗಳು: ಹಲವಾರು ತರಬೇತಿ-ಪರೀಕ್ಷಾ ವಿಭಜನೆಗಳಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ಸರಾಸರಿ ಮಾಡುವ ಮೂಲಕ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಂದಾಜಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಮಾದರಿಯು ಹೇಗೆ ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತದೆ ಎಂಬುದರ ಹೆಚ್ಚು ಸ್ಥಿರ ಮತ್ತು ನಿಖರವಾದ ಅಳತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
- ಡೇಟಾದ ಉತ್ತಮ ಬಳಕೆ: ಎಲ್ಲಾ ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಅಂತಿಮವಾಗಿ ವಿಭಿನ್ನ ಫೋಲ್ಡ್‌ಗಳಲ್ಲಿ ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷೆ ಎರಡಕ್ಕೂ ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಸೀಮಿತ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ.
- ಓವರ್‌ಫಿಟ್ಟಿಂಗ್/ಅಂಡರ್‌ಫಿಟ್ಟಿಂಗ್ ಪತ್ತೆ: ಎಲ್ಲಾ ಫೋಲ್ಡ್‌ಗಳಲ್ಲಿ ಸ್ಥಿರವಾಗಿ ಕಳಪೆ ಕಾರ್ಯಕ್ಷಮತೆಯು ಅಂಡರ್‌ಫಿಟ್ಟಿಂಗ್ ಅನ್ನು ಸೂಚಿಸಬಹುದು, ಆದರೆ ಅತ್ಯುತ್ತಮ ತರಬೇತಿ ಕಾರ್ಯಕ್ಷಮತೆ ಆದರೆ ಫೋಲ್ಡ್‌ಗಳಲ್ಲಿ ಕಳಪೆ ಪರೀಕ್ಷಾ ಕಾರ್ಯಕ್ಷಮತೆ ಓವರ್‌ಫಿಟ್ಟಿಂಗ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ.
ಸ್ಕಿಕಿಟ್-ಲರ್ನ್‌ನ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಟೂಲ್‌ಕಿಟ್
ಪೈಥಾನ್‌ನಲ್ಲಿ ಯಂತ್ರ ಕಲಿಕೆಗಾಗಿ ಒಂದು ಪ್ರಮುಖ ಲೈಬ್ರರಿಯಾದ ಸ್ಕಿಕಿಟ್-ಲರ್ನ್, ವಿವಿಧ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಲು ತನ್ನ model_selection ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಸಮೃದ್ಧ ಪರಿಕರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಕಾರ್ಯಗಳಿಂದ ಪ್ರಾರಂಭಿಸೋಣ.
cross_val_score: ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ತ್ವರಿತ ಅವಲೋಕನ
cross_val_score ಕಾರ್ಯವು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್‌ನಲ್ಲಿ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಮಾಡಲು ಬಹುಶಃ ಸರಳವಾದ ಮಾರ್ಗವಾಗಿದೆ. ಇದು ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಮೂಲಕ ಸ್ಕೋರ್ ಅನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ, ಪ್ರತಿ ಫೋಲ್ಡ್‌ಗೆ ಒಂದರಂತೆ ಸ್ಕೋರ್‌ಗಳ ಅರೇ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಪ್ರಮುಖ ನಿಯತಾಂಕಗಳು:
estimator: ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿ ವಸ್ತು (ಉದಾಹರಣೆಗೆ,LogisticRegression()).X: ವೈಶಿಷ್ಟ್ಯಗಳು (ತರಬೇತಿ ಡೇಟಾ).y: ಗುರಿ ವೇರಿಯಬಲ್.cv: ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ವಿಭಜನಾ ತಂತ್ರವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ (ಫೋಲ್ಡ್‌ಗಳ ಸಂಖ್ಯೆ), ಒಂದು CV ಸ್ಪ್ಲಿಟರ್ ವಸ್ತು (ಉದಾಹರಣೆಗೆ,KFold()), ಅಥವಾ ಪುನರಾವರ್ತಿಸಬಹುದಾದ (iterable) ಆಗಿರಬಹುದು.scoring: ಪರೀಕ್ಷಾ ಸೆಟ್‌ನಲ್ಲಿನ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಒಂದು ಸ್ಟ್ರಿಂಗ್ (ಉದಾಹರಣೆಗೆ, 'accuracy', 'f1', 'roc_auc') ಅಥವಾ ಕರೆಯಬಹುದಾದ (callable) ಕಾರ್ಯ.
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
# Load a sample dataset
iris = load_iris()
X, y = iris.data, iris.target
# Initialize a model
model = LogisticRegression(max_iter=200)
# Perform 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"Cross-validation scores: {scores}")
print(f"Mean accuracy: {scores.mean():.4f}")
print(f"Standard deviation of accuracy: {scores.std():.4f}")
ಈ ಔಟ್‌ಪುಟ್ ನಿಖರತೆಯ ಸ್ಕೋರ್‌ಗಳ ಅರೇ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಪ್ರತಿ ಫೋಲ್ಡ್‌ಗೆ ಒಂದು. ಸರಾಸರಿ ಮತ್ತು ಪ್ರಮಾಣಿತ ವಿಚಲನವು ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಕೇಂದ್ರ ಪ್ರವೃತ್ತಿ ಮತ್ತು ವ್ಯತ್ಯಾಸವನ್ನು ನಿಮಗೆ ನೀಡುತ್ತದೆ.
cross_validate: ಹೆಚ್ಚು ವಿವರವಾದ ಮೆಟ್ರಿಕ್ಸ್
cross_val_score ಕೇವಲ ಒಂದೇ ಮೆಟ್ರಿಕ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸಿದರೆ, cross_validate ಹೆಚ್ಚು ವಿವರವಾದ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಫೋಲ್ಡ್‌ಗೆ ತರಬೇತಿ ಸ್ಕೋರ್‌ಗಳು, ಫಿಟ್ ಸಮಯಗಳು ಮತ್ತು ಸ್ಕೋರ್ ಸಮಯಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಮೆಟ್ರಿಕ್‌ಗಳ ನಿಘಂಟನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಅನೇಕ ಮೌಲ್ಯಮಾಪನ ಮೆಟ್ರಿಕ್‌ಗಳು ಅಥವಾ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಯಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾದಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.
from sklearn.model_selection import cross_validate
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target
model = LogisticRegression(max_iter=200)
# Perform 5-fold cross-validation with multiple scoring metrics
scoring = ['accuracy', 'precision_macro', 'recall_macro', 'f1_macro']
results = cross_validate(model, X, y, cv=5, scoring=scoring, return_train_score=True)
print("Cross-validation results:")
for metric_name, values in results.items():
print(f" {metric_name}: {values}")
print(f" Mean {metric_name}: {values.mean():.4f}")
print(f" Std {metric_name}: {values.std():.4f}")
return_train_score=True ನಿಯತಾಂಕವು ಓವರ್‌ಫಿಟ್ಟಿಂಗ್ ಅನ್ನು ಪತ್ತೆಹಚ್ಚಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ: train_score test_score ಗಿಂತ ಹೆಚ್ಚಿದ್ದರೆ, ನಿಮ್ಮ ಮಾದರಿಯು ಓವರ್‌ಫಿಟ್ಟಿಂಗ್ ಆಗುವ ಸಾಧ್ಯತೆಯಿದೆ.
ಸ್ಕಿಕಿಟ್-ಲರ್ನ್‌ನಲ್ಲಿ ಪ್ರಮುಖ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರಗಳು
ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಹಲವಾರು ವಿಶೇಷ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ನೀಡುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ವಿಭಿನ್ನ ಡೇಟಾ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಮಾಡೆಲಿಂಗ್ ಸನ್ನಿವೇಶಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ. ಅರ್ಥಪೂರ್ಣ ಮತ್ತು ಪಕ್ಷಪಾತವಿಲ್ಲದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಂದಾಜುಗಳನ್ನು ಪಡೆಯಲು ಸರಿಯಾದ ತಂತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
1. K-ಫೋಲ್ಡ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್
ವಿವರಣೆ: K-ಫೋಲ್ಡ್ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರವಾಗಿದೆ. ಡೇಟಾಸೆಟ್ ಅನ್ನು k ಸಮಾನ ಗಾತ್ರದ ಫೋಲ್ಡ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ. ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ, ಒಂದು ಫೋಲ್ಡ್ ಅನ್ನು ಪರೀಕ್ಷಾ ಸೆಟ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಉಳಿದ k-1 ಫೋಲ್ಡ್‌ಗಳನ್ನು ತರಬೇತಿ ಸೆಟ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು k ಬಾರಿ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ, ಪ್ರತಿ ಫೋಲ್ಡ್ ನಿಖರವಾಗಿ ಒಮ್ಮೆ ಪರೀಕ್ಷಾ ಸೆಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಯಾವಾಗ ಬಳಸಬೇಕು: ಇದು ಅನೇಕ ಪ್ರಮಾಣಿತ ವರ್ಗೀಕರಣ ಮತ್ತು ರಿಗ್ರೆಷನ್ ಕಾರ್ಯಗಳಿಗೆ ಸೂಕ್ತವಾದ ಸಾಮಾನ್ಯ-ಉದ್ದೇಶದ ಆಯ್ಕೆಯಾಗಿದೆ, ಅಲ್ಲಿ ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳು ಸ್ವತಂತ್ರ ಮತ್ತು ಒಂದೇ ರೀತಿ ವಿತರಿಸಲ್ಪಡುತ್ತವೆ (i.i.d.).
ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು:
- ಸಾಮಾನ್ಯವಾಗಿ,
kಅನ್ನು 5 ಅಥವಾ 10 ಕ್ಕೆ ಹೊಂದಿಸಲಾಗಿದೆ. ಹೆಚ್ಚಿನkಕಡಿಮೆ ಪಕ್ಷಪಾತದ ಆದರೆ ಹೆಚ್ಚು ಕಂಪ್ಯೂಟೇಶನಲ್ ದುಬಾರಿ ಅಂದಾಜುಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. - ಅಸಮತೋಲಿತ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಸಮಸ್ಯೆಯಾಗಬಹುದು, ಏಕೆಂದರೆ ಕೆಲವು ಫೋಲ್ಡ್‌ಗಳು ಅಲ್ಪಸಂಖ್ಯಾತ ವರ್ಗದ ಮಾದರಿಗಳನ್ನು ಬಹಳ ಕಡಿಮೆ ಅಥವಾ ಹೊಂದಿಲ್ಲದಿರಬಹುದು.
from sklearn.model_selection import KFold
import numpy as np
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([0, 1, 0, 1, 0, 1])
kf = KFold(n_splits=3, shuffle=True, random_state=42)
print("K-Fold Cross-validation splits:")
for i, (train_index, test_index) in enumerate(kf.split(X)):
print(f" Fold {i+1}:")
print(f" TRAIN: {train_index}, TEST: {test_index}")
print(f" Train data X: {X[train_index]}, y: {y[train_index]}")
print(f" Test data X: {X[test_index]}, y: {y[test_index]}")
shuffle=True ನಿಯತಾಂಕವು ವಿಭಜಿಸುವ ಮೊದಲು ಡೇಟಾವನ್ನು ಯಾದೃಚ್ಛಿಕಗೊಳಿಸಲು ಮುಖ್ಯವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ನಿಮ್ಮ ಡೇಟಾವು ಸಹಜ ಕ್ರಮವನ್ನು ಹೊಂದಿದ್ದರೆ. random_state ಷಫಲ್ ಮಾಡುವ ಪುನರುತ್ಪಾದಕತೆಯನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ.
2. ಸ್ತ್ರತೀಕೃತ K-ಫೋಲ್ಡ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್
ವಿವರಣೆ: ಇದು K-ಫೋಲ್ಡ್‌ನ ಒಂದು ಮಾರ್ಪಾಡು, ಇದನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ವರ್ಗೀಕರಣ ಕಾರ್ಯಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಅಸಮತೋಲಿತ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ. ಇದು ಪ್ರತಿ ಫೋಲ್ಡ್ ಸಂಪೂರ್ಣ ಸೆಟ್‌ನಂತೆಯೇ ಪ್ರತಿ ಗುರಿ ವರ್ಗದ ಮಾದರಿಗಳ ಸರಿಸುಮಾರು ಅದೇ ಶೇಕಡಾವಾರು ಪ್ರಮಾಣವನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಫೋಲ್ಡ್‌ಗಳು ಅಲ್ಪಸಂಖ್ಯಾತ ವರ್ಗದ ಮಾದರಿಗಳಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಮುಕ್ತವಾಗಿರುವುದನ್ನು ತಡೆಯುತ್ತದೆ, ಇದು ಕಳಪೆ ಮಾದರಿ ತರಬೇತಿ ಅಥವಾ ಪರೀಕ್ಷೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಯಾವಾಗ ಬಳಸಬೇಕು: ವರ್ಗೀಕರಣ ಸಮಸ್ಯೆಗಳಿಗೆ ಇದು ಅತ್ಯಗತ್ಯ, ವಿಶೇಷವಾಗಿ ಅಸಮತೋಲಿತ ವರ್ಗ ವಿತರಣೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ, ಇದು ವೈದ್ಯಕೀಯ ರೋಗನಿರ್ಣಯ (ಉದಾ., ಅಪರೂಪದ ರೋಗ ಪತ್ತೆ), ವಂಚನೆ ಪತ್ತೆ, ಅಥವಾ ಅಸಂಗತತೆ ಪತ್ತೆಯಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿದೆ.
from sklearn.model_selection import StratifiedKFold
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [5,6], [7,8], [9,10], [11,12]])
y_imbalanced = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1]) # 60% class 0, 40% class 1
skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)
print("Stratified K-Fold Cross-validation splits:")
for i, (train_index, test_index) in enumerate(skf.split(X, y_imbalanced)):
print(f" Fold {i+1}:")
print(f" TRAIN: {train_index}, TEST: {test_index}")
print(f" Train y distribution: {np.bincount(y_imbalanced[train_index])}")
print(f" Test y distribution: {np.bincount(y_imbalanced[test_index])}")
np.bincount ಪ್ರತಿ ಫೋಲ್ಡ್‌ನಲ್ಲಿ ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳು ಎರಡೂ ಒಂದೇ ರೀತಿಯ ವರ್ಗಗಳ ಅನುಪಾತವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ (ಉದಾಹರಣೆಗೆ, 60/40 ವಿಭಜನೆ ಅಥವಾ n_splits ನೀಡಿದರೆ ಸಾಧ್ಯವಾದಷ್ಟು ಹತ್ತಿರ).
3. ಲೀವ್-ಒನ್-ಔಟ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ (LOOCV)
ವಿವರಣೆ: LOOCV ಎಂಬುದು K-ಫೋಲ್ಡ್‌ನ ತೀವ್ರ ಪ್ರಕರಣವಾಗಿದೆ, ಇಲ್ಲಿ k ಮಾದರಿಗಳ ಸಂಖ್ಯೆಗೆ (n) ಸಮಾನವಾಗಿರುತ್ತದೆ. ಪ್ರತಿ ಫೋಲ್ಡ್‌ಗೆ, ಒಂದು ಮಾದರಿಯನ್ನು ಪರೀಕ್ಷಾ ಸೆಟ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಉಳಿದ n-1 ಮಾದರಿಗಳನ್ನು ತರಬೇತಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇದರರ್ಥ ಮಾದರಿಯನ್ನು n ಬಾರಿ ತರಬೇತಿ ಮತ್ತು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ.
ಯಾವಾಗ ಬಳಸಬೇಕು:
- ಪ್ರತಿ ಪುನರಾವರ್ತನೆಗೆ ತರಬೇತಿ ಡೇಟಾವನ್ನು ಗರಿಷ್ಠಗೊಳಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿರುವ ಬಹಳ ಸಣ್ಣ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.
- ಮಾದರಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಬಹುತೇಕ ಪಕ್ಷಪಾತವಿಲ್ಲದ ಅಂದಾಜನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು:
- ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಅತಿಯಾಗಿ ಕಂಪ್ಯೂಟೇಶನಲ್ ದುಬಾರಿಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಮಾದರಿಯನ್ನು
nಬಾರಿ ತರಬೇತಿ ಮಾಡಲು ಅಗತ್ಯವಿದೆ. - ಪರೀಕ್ಷಾ ಸೆಟ್ ತುಂಬಾ ಚಿಕ್ಕದಾಗಿರುವುದರಿಂದ ಪುನರಾವರ್ತನೆಗಳಾದ್ಯಂತ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಂದಾಜುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನ ವ್ಯತ್ಯಾಸ.
from sklearn.model_selection import LeaveOneOut
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
y = np.array([0, 1, 0, 1])
loo = LeaveOneOut()
print("Leave-One-Out Cross-validation splits:")
for i, (train_index, test_index) in enumerate(loo.split(X)):
print(f" Iteration {i+1}: TRAIN: {train_index}, TEST: {test_index}")
4. ಶಫಲ್ ಸ್ಪ್ಲಿಟ್ ಮತ್ತು ಸ್ತ್ರತೀಕೃತ ಶಫಲ್ ಸ್ಪ್ಲಿಟ್
ವಿವರಣೆ: ಪ್ರತಿ ಮಾದರಿಯು ಪರೀಕ್ಷಾ ಸೆಟ್‌ನಲ್ಲಿ ನಿಖರವಾಗಿ ಒಮ್ಮೆ ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ಖಾತರಿಪಡಿಸುವ K-ಫೋಲ್ಡ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ, ಶಫಲ್ ಸ್ಪ್ಲಿಟ್ n_splits ಯಾದೃಚ್ಛಿಕ ತರಬೇತಿ/ಪರೀಕ್ಷಾ ವಿಭಜನೆಗಳನ್ನು ಸೆಳೆಯುತ್ತದೆ. ಪ್ರತಿ ವಿಭಜನೆಗೆ, ಡೇಟಾದ ಒಂದು ಭಾಗವನ್ನು ತರಬೇತಿಗಾಗಿ ಯಾದೃಚ್ಛಿಕವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ, ಮತ್ತು ಮತ್ತೊಂದು (ಪ್ರತ್ಯೇಕ) ಭಾಗವನ್ನು ಪರೀಕ್ಷೆಗಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ. ಇದು ಪುನರಾವರ್ತಿತ ಯಾದೃಚ್ಛಿಕ ಉಪ-ಮಾದರಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ.
ಯಾವಾಗ ಬಳಸಬೇಕು:
- K-ಫೋಲ್ಡ್‌ನಲ್ಲಿ ಫೋಲ್ಡ್‌ಗಳ ಸಂಖ್ಯೆ (
k) ನಿರ್ಬಂಧಿತವಾಗಿದ್ದಾಗ, ಆದರೆ ನೀವು ಇನ್ನೂ ಅನೇಕ ಸ್ವತಂತ್ರ ವಿಭಜನೆಗಳನ್ನು ಬಯಸುತ್ತೀರಿ. - K-ಫೋಲ್ಡ್ ಕಂಪ್ಯೂಟೇಶನಲ್ ತೀವ್ರವಾಗಿರುವ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಥವಾ ನೀವು ಕೇವಲ
1/kಗಿಂತ ಹೆಚ್ಚಾಗಿ ಪರೀಕ್ಷಾ ಸೆಟ್ ಗಾತ್ರದ ಮೇಲೆ ಹೆಚ್ಚು ನಿಯಂತ್ರಣವನ್ನು ಬಯಸುವಾಗ. StratifiedShuffleSplitಅಸಮತೋಲಿತ ಡೇಟಾದೊಂದಿಗೆ ವರ್ಗೀಕರಣಕ್ಕಾಗಿ ಆದ್ಯತೆಯ ಆಯ್ಕೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಪ್ರತಿ ವಿಭಜನೆಯಲ್ಲಿ ವರ್ಗ ವಿತರಣೆಯನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ.
ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು: ಎಲ್ಲಾ ಮಾದರಿಗಳು ಕನಿಷ್ಠ ಒಂದು ವಿಭಜನೆಗೆ ಪರೀಕ್ಷಾ ಸೆಟ್‌ನಲ್ಲಿ, ಅಥವಾ ತರಬೇತಿ ಸೆಟ್‌ನಲ್ಲಿ ಇರುವುದು ಖಾತರಿಯಿಲ್ಲ, ಆದರೂ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ವಿಭಜನೆಗಳಿಗೆ ಇದು ಸಂಭವಿಸುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ.
from sklearn.model_selection import ShuffleSplit, StratifiedShuffleSplit
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4], [5,6], [7,8], [9,10], [11,12]])
y = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) # Imbalanced data for StratifiedShuffleSplit
# ShuffleSplit example
ss = ShuffleSplit(n_splits=5, test_size=0.3, random_state=42)
print("ShuffleSplit Cross-validation splits:")
for i, (train_index, test_index) in enumerate(ss.split(X)):
print(f" Split {i+1}: TRAIN: {train_index}, TEST: {test_index}")
# StratifiedShuffleSplit example
sss = StratifiedShuffleSplit(n_splits=5, test_size=0.3, random_state=42)
print("\nStratifiedShuffleSplit Cross-validation splits (y distribution maintained):")
for i, (train_index, test_index) in enumerate(sss.split(X, y)):
print(f" Split {i+1}:")
print(f" TRAIN: {train_index}, TEST: {test_index}")
print(f" Train y distribution: {np.bincount(y[train_index])}")
print(f" Test y distribution: {np.bincount(y[test_index])}")
5. ಟೈಮ್ ಸೀರೀಸ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ (TimeSeriesSplit)
ವಿವರಣೆ: ಪ್ರಮಾಣಿತ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ವಿಧಾನಗಳು ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳು ಸ್ವತಂತ್ರವಾಗಿವೆ ಎಂದು ಊಹಿಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಸಮಯ ಸರಣಿ ಡೇಟಾದಲ್ಲಿ, ವೀಕ್ಷಣೆಗಳನ್ನು ಆದೇಶಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ತಾತ್ಕಾಲಿಕ ಅವಲಂಬನೆಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ. ಸಮಯ ಸರಣಿ ಡೇಟಾವನ್ನು ಷಫಲ್ ಮಾಡುವುದು ಅಥವಾ ಯಾದೃಚ್ಛಿಕವಾಗಿ ವಿಭಜಿಸುವುದು ಡೇಟಾ ಸೋರಿಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಅಲ್ಲಿ ಮಾದರಿಯು ಹಿಂದಿನ ಡೇಟಾವನ್ನು ಊಹಿಸಲು ಭವಿಷ್ಯದ ಡೇಟಾದ ಮೇಲೆ ತರಬೇತಿ ನೀಡುತ್ತದೆ, ಇದು ಅತಿಯಾಗಿ ಆಶಾವಾದಿ ಮತ್ತು ಅವಾಸ್ತವಿಕ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಂದಾಜಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
TimeSeriesSplit ತರಬೇತಿ/ಪರೀಕ್ಷಾ ವಿಭಜನೆಗಳನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಇದನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಪರೀಕ್ಷಾ ಸೆಟ್ ಯಾವಾಗಲೂ ತರಬೇತಿ ಸೆಟ್‌ನ ನಂತರ ಬರುತ್ತದೆ. ಇದು ಡೇಟಾವನ್ನು ತರಬೇತಿ ಸೆಟ್ ಮತ್ತು ನಂತರದ ಪರೀಕ್ಷಾ ಸೆಟ್ ಆಗಿ ವಿಭಜಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ನಂತರ ತರಬೇತಿ ಸೆಟ್ ಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್ ಅನ್ನು ಸಮಯಕ್ಕೆ ಮುಂದಕ್ಕೆ ಸ್ಲೈಡ್ ಮಾಡುತ್ತದೆ.
ಯಾವಾಗ ಬಳಸಬೇಕು: ಕೇವಲ ಸಮಯ ಸರಣಿ ಮುನ್ಸೂಚನೆ ಅಥವಾ ಯಾವುದೇ ಅನುಕ್ರಮ ಡೇಟಾಗೆ, ಅಲ್ಲಿ ವೀಕ್ಷಣೆಗಳ ತಾತ್ಕಾಲಿಕ ಕ್ರಮವನ್ನು ಸಂರಕ್ಷಿಸಬೇಕು.
ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು: ಪ್ರತಿ ವಿಭಜನೆಯೊಂದಿಗೆ ತರಬೇತಿ ಸೆಟ್‌ಗಳು ದೊಡ್ಡದಾಗುತ್ತವೆ, ಇದು ವಿಭಿನ್ನ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಕಾರಣವಾಗಬಹುದು, ಮತ್ತು ಆರಂಭಿಕ ತರಬೇತಿ ಸೆಟ್‌ಗಳು ಬಹಳ ಚಿಕ್ಕದಾಗಿರಬಹುದು.
from sklearn.model_selection import TimeSeriesSplit
import pandas as pd
# Simulate time series data
dates = pd.to_datetime(pd.date_range(start='2023-01-01', periods=100, freq='D'))
X_ts = np.arange(100).reshape(-1, 1)
y_ts = np.sin(np.arange(100) / 10) + np.random.randn(100) * 0.1 # Some time-dependent target
tscv = TimeSeriesSplit(n_splits=5)
print("Time Series Cross-validation splits:")
for i, (train_index, test_index) in enumerate(tscv.split(X_ts)):
print(f" Fold {i+1}:")
print(f" TRAIN indices: {train_index[0]} to {train_index[-1]}")
print(f" TEST indices: {test_index[0]} to {test_index[-1]}")
# Verify that test_index always starts after train_index ends
assert train_index[-1] < test_index[0]
ಈ ವಿಧಾನವು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಯಾವಾಗಲೂ ಭವಿಷ್ಯದ ಡೇಟಾದ ಮೇಲೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅದನ್ನು ತರಬೇತಿ ನೀಡಿದ ಡೇಟಾಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಸಮಯ-ಅವಲಂಬಿತ ಸಮಸ್ಯೆಗಳಿಗೆ ನೈಜ-ಜಗತ್ತಿನ ನಿಯೋಜನೆ ಸನ್ನಿವೇಶಗಳನ್ನು ಅನುಕರಿಸುತ್ತದೆ.
6. ಗ್ರೂಪ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ (GroupKFold, LeaveOneGroupOut)
ವಿವರಣೆ: ಕೆಲವು ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ, ಮಾದರಿಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವತಂತ್ರವಾಗಿರುವುದಿಲ್ಲ; ಅವು ನಿರ್ದಿಷ್ಟ ಗುಂಪುಗಳಿಗೆ ಸೇರಿರಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದೇ ರೋಗಿಯಿಂದ ಅನೇಕ ವೈದ್ಯಕೀಯ ಅಳತೆಗಳು, ಒಂದೇ ಸಂವೇದಕದಿಂದ ಅನೇಕ ವೀಕ್ಷಣೆಗಳು, ಅಥವಾ ಒಂದೇ ಗ್ರಾಹಕರಿಂದ ಅನೇಕ ಆರ್ಥಿಕ ವಹಿವಾಟುಗಳು. ಈ ಗುಂಪುಗಳನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಳಾದ್ಯಂತ ವಿಭಜಿಸಿದರೆ, ಮಾದರಿಯು ಗುಂಪು-ನಿರ್ದಿಷ್ಟ ಮಾದರಿಗಳನ್ನು ಕಲಿಯಬಹುದು ಮತ್ತು ಹೊಸ, ಕಾಣದ ಗುಂಪುಗಳಿಗೆ ಸಾಮಾನ್ಯೀಕರಿಸಲು ವಿಫಲವಾಗಬಹುದು. ಇದು ಡೇಟಾ ಸೋರಿಕೆಯ ಒಂದು ರೂಪವಾಗಿದೆ.
ಗ್ರೂಪ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರಗಳು ಒಂದೇ ಗುಂಪಿನ ಎಲ್ಲಾ ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳು ಸಂಪೂರ್ಣವಾಗಿ ತರಬೇತಿ ಸೆಟ್‌ನಲ್ಲಿ ಅಥವಾ ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಾ ಸೆಟ್‌ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಎಂದಿಗೂ ಎರಡರಲ್ಲೂ ಅಲ್ಲ.
ಯಾವಾಗ ಬಳಸಬೇಕು: ನಿಮ್ಮ ಡೇಟಾವು ಸಹಜ ಗುಂಪುಗಳನ್ನು ಹೊಂದಿರುವಾಗ, ಅವುಗಳನ್ನು ಫೋಲ್ಡ್‌ಗಳಾದ್ಯಂತ ವಿಭಜಿಸಿದರೆ ಪಕ್ಷಪಾತವನ್ನು ಪರಿಚಯಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ ರೇಖಾಂಶ ಅಧ್ಯಯನಗಳು, ಬಹು ಸಾಧನಗಳಿಂದ ಸಂವೇದಕ ಡೇಟಾ, ಅಥವಾ ಗ್ರಾಹಕ-ನಿರ್ದಿಷ್ಟ ನಡವಳಿಕೆ ಮಾಡೆಲಿಂಗ್.
ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು: ಪ್ರತಿ ಮಾದರಿಗೆ ಗುಂಪು ಗುರುತನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ 'groups' ಅರೇ ಅನ್ನು .split() ವಿಧಾನಕ್ಕೆ ರವಾನಿಸಬೇಕು.
from sklearn.model_selection import GroupKFold
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16]])
y = np.array([0, 1, 0, 1, 0, 1, 0, 1])
# Two groups: samples 0-3 belong to Group A, samples 4-7 belong to Group B
groups = np.array(['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B'])
gkf = GroupKFold(n_splits=2) # We'll use 2 splits to clearly separate groups
print("Group K-Fold Cross-validation splits:")
for i, (train_index, test_index) in enumerate(gkf.split(X, y, groups)):
print(f" Fold {i+1}:")
print(f" TRAIN indices: {train_index}, GROUPS: {groups[train_index]}")
print(f" TEST indices: {test_index}, GROUPS: {groups[test_index]}")
# Verify that no group appears in both train and test sets for a single fold
assert len(set(groups[train_index]).intersection(set(groups[test_index]))) == 0
ಇತರ ಗುಂಪು-ಅರಿವಿನ ತಂತ್ರಗಳು LeaveOneGroupOut (ಪ್ರತಿ ಅನನ್ಯ ಗುಂಪು ಒಮ್ಮೆ ಪರೀಕ್ಷಾ ಸೆಟ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ) ಮತ್ತು LeavePGroupsOut (ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಾಗಿ P ಗುಂಪುಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಿ) ಒಳಗೊಂಡಿವೆ.
ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್‌ನೊಂದಿಗೆ ಸುಧಾರಿತ ಮಾದರಿ ಆಯ್ಕೆ
ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಕೇವಲ ಒಂದೇ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಮಾತ್ರವಲ್ಲ; ಇದು ಅತ್ಯುತ್ತಮ ಮಾದರಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಮತ್ತು ಅದರ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಟ್ಯೂನ್ ಮಾಡಲು ಸಹ ಅವಿಭಾಜ್ಯವಾಗಿದೆ.
GridSearchCV ಮತ್ತು RandomizedSearchCV ನೊಂದಿಗೆ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಟ್ಯೂನಿಂಗ್
ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಅವು ಡೇಟಾದಿಂದ ಕಲಿಯುವುದಿಲ್ಲ ಆದರೆ ತರಬೇತಿಗೆ ಮುನ್ನ ಹೊಂದಿಸಬೇಕು. ಈ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿಗೆ ಸೂಕ್ತ ಮೌಲ್ಯಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾಸೆಟ್-ಅವಲಂಬಿತವಾಗಿರುತ್ತವೆ. ಸ್ಕಿಕಿಟ್-ಲರ್ನ್‌ನ GridSearchCV ಮತ್ತು RandomizedSearchCV, ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಅತ್ಯುತ್ತಮ ಸಂಯೋಜನೆಯನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಹುಡುಕಲು ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ.
GridSearchCV: ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪ್ಯಾರಾಮೀಟರ್ ಗ್ರಿಡ್ ಮೂಲಕ ಸಂಪೂರ್ಣವಾಗಿ ಹುಡುಕುತ್ತದೆ, ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಬಳಸಿ ಪ್ರತಿಯೊಂದು ಸಂಭವನೀಯ ಸಂಯೋಜನೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ. ಇದು ಗ್ರಿಡ್‌ನಲ್ಲಿ ಅತ್ಯುತ್ತಮ ಸಂಯೋಜನೆಯನ್ನು ಕಂಡುಹಿಡಿಯುವುದನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ ಆದರೆ ದೊಡ್ಡ ಗ್ರಿಡ್‌ಗಳಿಗೆ ಕಂಪ್ಯೂಟೇಶನಲ್ ದುಬಾರಿಯಾಗಿರಬಹುದು.RandomizedSearchCV: ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವಿತರಣೆಗಳಿಂದ ಸ್ಥಿರ ಸಂಖ್ಯೆಯ ಪ್ಯಾರಾಮೀಟರ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಮಾದರಿ ಮಾಡುತ್ತದೆ. ದೊಡ್ಡ ಹುಡುಕಾಟ ಸ್ಥಳಗಳಿಗೆGridSearchCVಗಿಂತ ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಪ್ರತಿ ಸಂಯೋಜನೆಯನ್ನು ಪ್ರಯತ್ನಿಸುವುದಿಲ್ಲ, ಸಾಮಾನ್ಯವಾಗಿ ಕಡಿಮೆ ಸಮಯದಲ್ಲಿ ಉತ್ತಮ ಪರಿಹಾರವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ.
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC
from sklearn.datasets import load_breast_cancer
# Load a sample dataset
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
# Define the model and parameter grid
model = SVC()
param_grid = {
'C': [0.1, 1, 10],
'kernel': ['linear', 'rbf']
}
# Perform GridSearchCV with 5-fold cross-validation
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid_search.fit(X, y)
print(f"Best parameters: {grid_search.best_params_}")
print(f"Best cross-validation accuracy: {grid_search.best_score_:.4f}")
GridSearchCV ಮತ್ತು RandomizedSearchCV ಎರಡೂ cv ನಿಯತಾಂಕವನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ, ಇದು ಹಿಂದೆ ಚರ್ಚಿಸಿದ ಯಾವುದೇ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ಅಸಮತೋಲಿತ ವರ್ಗೀಕರಣ ಕಾರ್ಯಗಳಿಗಾಗಿ StratifiedKFold).
ನೆಸ್ಟೆಡ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್: ಅತಿಯಾಗಿ ಆಶಾವಾದಿ ಅಂದಾಜುಗಳನ್ನು ತಡೆಯುವುದು
ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಟ್ಯೂನಿಂಗ್‌ಗಾಗಿ ನೀವು ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಅನ್ನು ಬಳಸುವಾಗ (ಉದಾ., GridSearchCV ನೊಂದಿಗೆ), ಮತ್ತು ನಂತರ ಕಂಡುಬಂದ ಅತ್ಯುತ್ತಮ ನಿಯತಾಂಕಗಳನ್ನು ಬಾಹ್ಯ ಪರೀಕ್ಷಾ ಸೆಟ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಬಳಸಿದಾಗ, ನಿಮ್ಮ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅತಿಯಾದ ಆಶಾವಾದಿ ಅಂದಾಜು ನಿಮಗೆ ಇನ್ನೂ ಸಿಗಬಹುದು. ಇದು ಏಕೆಂದರೆ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಆಯ್ಕೆಯೇ ಡೇಟಾ ಸೋರಿಕೆಯ ಒಂದು ರೂಪವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ: ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣ ತರಬೇತಿ ಡೇಟಾವನ್ನು (ಆಂತರಿಕ ಲೂಪ್‌ನ ಮೌಲ್ಯಮಾಪನ ಫೋಲ್ಡ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ) ಆಧರಿಸಿ ಉತ್ತಮಗೊಳಿಸಲಾಯಿತು, ಇದು ಮಾದರಿಯನ್ನು ಪರೀಕ್ಷಾ ಸೆಟ್‌ನ ಗುಣಲಕ್ಷಣಗಳ ಬಗ್ಗೆ ಸ್ವಲ್ಪ "ತಿಳುವಳಿಕೆ" ಇರುವಂತೆ ಮಾಡುತ್ತದೆ.
ನೆಸ್ಟೆಡ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಇದನ್ನು ನಿಭಾಯಿಸುವ ಹೆಚ್ಚು ಕಠಿಣ ವಿಧಾನವಾಗಿದೆ. ಇದು ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್‌ನ ಎರಡು ಪದರಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:
- ಹೊರಗಿನ ಲೂಪ್: ಸಾಮಾನ್ಯ ಮಾದರಿ ಮೌಲ್ಯಮಾಪನಕ್ಕಾಗಿ ಡೇಟಾಸೆಟ್ ಅನ್ನು K ಫೋಲ್ಡ್‌ಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ.
- ಒಳಗಿನ ಲೂಪ್: ಹೊರಗಿನ ಲೂಪ್‌ನ ಪ್ರತಿ ತರಬೇತಿ ಫೋಲ್ಡ್‌ಗಾಗಿ, ಇದು ಅತ್ಯುತ್ತಮ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್‌ನ ಮತ್ತೊಂದು ಸುತ್ತನ್ನು (ಉದಾ.,
GridSearchCVಬಳಸಿ) ನಿರ್ವಹಿಸುತ್ತದೆ. ನಂತರ ಮಾದರಿಯನ್ನು ಈ ಹೊರಗಿನ ತರಬೇತಿ ಫೋಲ್ಡ್‌ನಲ್ಲಿ ಈ ಸೂಕ್ತ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಬಳಸಿ ತರಬೇತಿ ನೀಡಲಾಗುತ್ತದೆ. - ಮೌಲ್ಯಮಾಪನ: ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಯನ್ನು (ಅತ್ಯುತ್ತಮ ಆಂತರಿಕ-ಲೂಪ್ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳೊಂದಿಗೆ) ನಂತರ ಅನುಗುಣವಾದ ಹೊರಗಿನ ಪರೀಕ್ಷಾ ಫೋಲ್ಡ್‌ನಲ್ಲಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ.
ಈ ರೀತಿಯಾಗಿ, ಪ್ರತಿ ಹೊರಗಿನ ಫೋಲ್ಡ್‌ಗಾಗಿ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಉತ್ತಮಗೊಳಿಸಲಾಗುತ್ತದೆ, ಕಾಣದ ಡೇಟಾದ ಮೇಲೆ ಮಾದರಿಯ ಸಾಮಾನ್ಯೀಕರಣ ಕಾರ್ಯಕ್ಷಮತೆಯ ನಿಜವಾದ ಪಕ್ಷಪಾತವಿಲ್ಲದ ಅಂದಾಜನ್ನು ಒದಗಿಸುತ್ತದೆ. ಹೆಚ್ಚು ಕಂಪ್ಯೂಟೇಶನಲ್ ತೀವ್ರವಾಗಿದ್ದರೂ, ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಟ್ಯೂನಿಂಗ್ ಒಳಗೊಂಡಿರುವಾಗ ಸದೃಢ ಮಾದರಿ ಆಯ್ಕೆಗಾಗಿ ನೆಸ್ಟೆಡ್ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಚಿನ್ನದ ಮಾನದಂಡವಾಗಿದೆ.
ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು
ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಅನ್ವಯಿಸಲು ಚಿಂತನಶೀಲ ಪರಿಗಣನೆಯ ಅಗತ್ಯವಿದೆ, ವಿಶೇಷವಾಗಿ ವಿವಿಧ ಜಾಗತಿಕ ಸಂದರ್ಭಗಳಿಂದ ವೈವಿಧ್ಯಮಯ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ.
- ಸರಿಯಾದ ತಂತ್ರವನ್ನು ಆರಿಸಿಕೊಳ್ಳಿ: ನಿಮ್ಮ ಡೇಟಾದ ಸಹಜ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಯಾವಾಗಲೂ ಪರಿಗಣಿಸಿ. ಅದು ಸಮಯ-ಅವಲಂಬಿತವೇ? ಅದು ಗುಂಪು ಮಾಡಿದ ಅವಲೋಕನಗಳನ್ನು ಹೊಂದಿದೆಯೇ? ವರ್ಗ ಲೇಬಲ್‌ಗಳು ಅಸಮತೋಲಿತವಾಗಿವೆಯೇ? ಇದು ವಾದಯೋಗ್ಯವಾಗಿ ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ನಿರ್ಧಾರವಾಗಿದೆ. ತಪ್ಪಾದ ಆಯ್ಕೆ (ಉದಾ., ಸಮಯ ಸರಣಿಯ ಮೇಲೆ K-ಫೋಲ್ಡ್) ನಿಮ್ಮ ಭೌಗೋಳಿಕ ಸ್ಥಳ ಅಥವಾ ಡೇಟಾಸೆಟ್ ಮೂಲವನ್ನು ಲೆಕ್ಕಿಸದೆ ಅಮಾನ್ಯ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
- ಡೇಟಾಸೆಟ್ ಗಾತ್ರ ಮತ್ತು ಕಂಪ್ಯೂಟೇಶನಲ್ ವೆಚ್ಚ: ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಕಡಿಮೆ ಫೋಲ್ಡ್‌ಗಳು (ಉದಾ., 10-ಫೋಲ್ಡ್ ಅಥವಾ LOOCV ಬದಲಿಗೆ 5-ಫೋಲ್ಡ್) ಅಥವಾ ಕಂಪ್ಯೂಟೇಶನಲ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು
ShuffleSplitನಂತಹ ವಿಧಾನಗಳು ಬೇಕಾಗುತ್ತವೆ. ವಿತರಿಸಿದ ಕಂಪ್ಯೂಟಿಂಗ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ಮತ್ತು ಕ್ಲೌಡ್ ಸೇವೆಗಳು (AWS, ಅಜುರೆ, ಗೂಗಲ್ ಕ್ಲೌಡ್‌ನಂತಹ) ಜಾಗತಿಕವಾಗಿ ಲಭ್ಯವಿವೆ ಮತ್ತು ತೀವ್ರ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡಬಹುದು. - ಪುನರುತ್ಪಾದಕತೆ: ನಿಮ್ಮ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಸ್ಪ್ಲಿಟರ್‌ಗಳಲ್ಲಿ ಯಾವಾಗಲೂ
random_stateಅನ್ನು ಹೊಂದಿಸಿ (ಉದಾ.,KFold(..., random_state=42)). ಇದು ನಿಮ್ಮ ಫಲಿತಾಂಶಗಳನ್ನು ಇತರರು ಪುನರುತ್ಪಾದಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ, ಅಂತರರಾಷ್ಟ್ರೀಯ ತಂಡಗಳಾದ್ಯಂತ ಪಾರದರ್ಶಕತೆ ಮತ್ತು ಸಹಯೋಗವನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ. - ಫಲಿತಾಂಶಗಳನ್ನು ಅರ್ಥೈಸಿಕೊಳ್ಳುವುದು: ಕೇವಲ ಸರಾಸರಿ ಸ್ಕೋರ್‌ಗಿಂತ ಹೆಚ್ಚಾಗಿ ನೋಡಿ. ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಸ್ಕೋರ್‌ಗಳ ಪ್ರಮಾಣಿತ ವಿಚಲನವು ನಿಮ್ಮ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ವ್ಯತ್ಯಾಸವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಪ್ರಮಾಣಿತ ವಿಚಲನವು ನಿಮ್ಮ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯು ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ವಿಭಜನೆಗಳಿಗೆ ಸೂಕ್ಷ್ಮವಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ, ಇದು ಒಂದು ಕಾಳಜಿಯಾಗಿರಬಹುದು.
- ಡೊಮೇನ್ ಜ್ಞಾನವೇ ಮುಖ್ಯ: ಡೇಟಾದ ಮೂಲ ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತಿಮುಖ್ಯವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಗ್ರಾಹಕರ ಡೇಟಾವು ವಿಭಿನ್ನ ಭೌಗೋಳಿಕ ಪ್ರದೇಶಗಳಿಂದ ಬರುತ್ತದೆ ಎಂದು ತಿಳಿದುಕೊಳ್ಳುವುದು, ಪ್ರಾದೇಶಿಕ ಮಾದರಿಗಳು ಬಲವಾಗಿದ್ದರೆ ಗುಂಪು-ಆಧಾರಿತ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಅಗತ್ಯವನ್ನು ಸೂಚಿಸಬಹುದು. ಡೇಟಾ ತಿಳುವಳಿಕೆಯ ಕುರಿತು ಜಾಗತಿಕ ಸಹಯೋಗವು ಇಲ್ಲಿ ಪ್ರಮುಖವಾಗಿದೆ.
- ನೈತಿಕ ಪರಿಗಣನೆಗಳು ಮತ್ತು ಪಕ್ಷಪಾತ: ಪರಿಪೂರ್ಣ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್‌ನೊಂದಿಗೆ ಸಹ, ನಿಮ್ಮ ಆರಂಭಿಕ ಡೇಟಾವು ಪಕ್ಷಪಾತಗಳನ್ನು (ಉದಾ., ಕೆಲವು ಜನಸಂಖ್ಯಾ ಗುಂಪುಗಳು ಅಥವಾ ಪ್ರದೇಶಗಳ ಕಡಿಮೆ ಪ್ರಾತಿನಿಧ್ಯ) ಹೊಂದಿದ್ದರೆ, ನಿಮ್ಮ ಮಾದರಿಯು ಆ ಪಕ್ಷಪಾತಗಳನ್ನು ಮುಂದುವರಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ. ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಸಾಮಾನ್ಯೀಕರಣವನ್ನು ಅಳೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಆದರೆ ಸಹಜ ಡೇಟಾ ಪಕ್ಷಪಾತಗಳನ್ನು ಸರಿಪಡಿಸುವುದಿಲ್ಲ. ಇವುಗಳನ್ನು ಪರಿಹರಿಸಲು ಎಚ್ಚರಿಕೆಯ ಡೇಟಾ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಪೂರ್ವ ಸಂಸ್ಕರಣೆ ಅಗತ್ಯವಿದೆ, ಆಗಾಗ್ಗೆ ವೈವಿಧ್ಯಮಯ ಸಾಂಸ್ಕೃತಿಕ ಮತ್ತು ಸಾಮಾಜಿಕ ದೃಷ್ಟಿಕೋನಗಳಿಂದ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ.
- ಸ್ಕೆಲಬಿಲಿಟಿ: ಅತ್ಯಂತ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ, ಪೂರ್ಣ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಅಸಾಧ್ಯವಾಗಬಹುದು. ಆರಂಭಿಕ ಮಾದರಿ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಸಬ್‌ಸಾಂಪ್ಲಿಂಗ್‌ನಂತಹ ತಂತ್ರಗಳನ್ನು ಪರಿಗಣಿಸಿ ಅಥವಾ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಂಯೋಜಿಸುವ ವಿಶೇಷ ವಿತರಿಸಿದ ಯಂತ್ರ ಕಲಿಕೆ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳನ್ನು ಬಳಸಿ.
ತೀರ್ಮಾನ
ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ಕೇವಲ ಒಂದು ತಂತ್ರವಲ್ಲ; ಇದು ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ನಂಬಲರ್ಹ ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು ಒಂದು ಮೂಲಭೂತ ತತ್ವವಾಗಿದೆ. ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ವಿವಿಧ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಲು ವ್ಯಾಪಕ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಪರಿಕರಗಳ ಸಂಗ್ರಹವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ವಿಶ್ವಾದ್ಯಂತ ದತ್ತಾಂಶ ವಿಜ್ಞಾನಿಗಳಿಗೆ ತಮ್ಮ ಮಾದರಿಗಳನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಮತ್ತು ಮಾಹಿತಿ ಆಧಾರಿತ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
K-ಫೋಲ್ಡ್, ಸ್ತ್ರತೀಕೃತ K-ಫೋಲ್ಡ್, ಟೈಮ್ ಸೀರೀಸ್ ಸ್ಪ್ಲಿಟ್, ಗ್ರೂಪ್‌ಕೆಫೋಲ್ಡ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಮತ್ತು ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್ ಟ್ಯೂನಿಂಗ್ ಮತ್ತು ಸದೃಢ ಮೌಲ್ಯಮಾಪನದಲ್ಲಿ ಈ ತಂತ್ರಗಳ ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಮಾದರಿ ಆಯ್ಕೆಯ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ನೀವು ಉತ್ತಮವಾಗಿ ಸಿದ್ಧರಾಗಿದ್ದೀರಿ. ನಿಮ್ಮ ಕ್ರಾಸ್-ವ್ಯಾಲಿಡೇಶನ್ ತಂತ್ರವನ್ನು ನಿಮ್ಮ ಡೇಟಾದ ಅನನ್ಯ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ನಿಮ್ಮ ಯಂತ್ರ ಕಲಿಕೆ ಯೋಜನೆಯ ನಿರ್ದಿಷ್ಟ ಗುರಿಗಳೊಂದಿಗೆ ಯಾವಾಗಲೂ ಹೊಂದಿಸಿ.
ಕೇವಲ ಭವಿಷ್ಯವಾಣಿಯನ್ನು ಮೀರಿ, ಯಾವುದೇ ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಸಾಮಾನ್ಯೀಕರಿಸಬಹುದಾದ, ಸದೃಢ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು ಈ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ. ಸ್ಕಿಕಿಟ್-ಲರ್ನ್‌ನೊಂದಿಗೆ ಮಾದರಿ ಆಯ್ಕೆಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ನಿಮ್ಮ ಪ್ರಯಾಣ ಈಗಷ್ಟೇ ಪ್ರಾರಂಭವಾಗಿದೆ!